﻿//#define _CRT_SECURE_NO_WARNINGS 1
//#include "vector.h"  // 引入vector实现
//#include <string>
//#include <cassert>
//#include <iostream>
//#include <sstream>  // 用于输入流测试
//
//// 辅助宏：移除特殊字符，改用"OK"/"FAIL"避免编码问题
//#define TEST_ASSERT(condition, msg) \
//    do { \
//        if (condition) { \
//            std::cout << "[OK] " << msg << std::endl; \
//        } else { \
//            std::cout << "[FAIL] " << msg << " (失败)" << std::endl; \
//        } \
//    } while (0)
//
//// 1. 测试用自定义类型（修正：添加默认构造函数，避免vector构造报错）
//class TestCustomType {
//public:
//    int _id;
//    std::string _name;
//
//    // 必须提供默认构造函数（vector的某些操作会用到）
//    TestCustomType() : _id(0), _name("default") {}
//    // 带参构造
//    TestCustomType(int id, const std::string& name) : _id(id), _name(name) {}
//
//    // 重载比较运算符（用于vector的==比较）
//    friend bool operator==(const TestCustomType& a, const TestCustomType& b) {
//        return a._id == b._id && a._name == b._name;
//    }
//    friend bool operator!=(const TestCustomType& a, const TestCustomType& b) {
//        return !(a == b);
//    }
//    friend bool operator<(const TestCustomType& a, const TestCustomType& b) {
//        if (a._id != b._id) return a._id < b._id;
//        return a._name < b._name;
//    }
//
//    // 重载输出运算符（用于打印vector内容）
//    friend std::ostream& operator<<(std::ostream& os, const TestCustomType& obj) {
//        os << "(" << obj._id << ", " << obj._name << ")";
//        return os;
//    }
//};
//
//// 2. 测试构造函数与析构
//void testConstructor() {
//    std::cout << "\n===== 1. 构造函数测试 =====" << std::endl;
//
//    // 2.1 默认构造
//    MyVector::vector<int> vec1;
//    TEST_ASSERT(vec1.empty() && vec1.size() == 0 && vec1.capacity() == 0, "默认构造空vector");
//
//    // 2.2 带大小的构造（内置类型）
//    MyVector::vector<int> vec2(3);
//    TEST_ASSERT(vec2.size() == 3 && vec2.capacity() == 3, "带大小的构造（int）");
//    TEST_ASSERT(vec2[0] == 0 && vec2[1] == 0, "内置类型默认初始化为0");
//
//    // 2.3 带大小+初始值的构造（内置类型）
//    MyVector::vector<int> vec3(4, 5);
//    TEST_ASSERT(vec3.size() == 4 && vec3[2] == 5, "带初始值的构造（int=5）");
//
//    // 2.4 拷贝构造
//    MyVector::vector<int> vec4(vec3);
//    TEST_ASSERT(vec4 == vec3 && vec4.capacity() == vec3.capacity(), "拷贝构造（深拷贝）");
//
//    // 2.5 自定义类型构造（带初始值）
//    MyVector::vector<TestCustomType> vec5(2, TestCustomType(10, "test"));
//    TEST_ASSERT(vec5.size() == 2 && vec5[1]._id == 10, "自定义类型带初始值构造");
//}
//
//// 3. 测试迭代器与元素访问
//void testIteratorAndAccess() {
//    std::cout << "\n===== 2. 迭代器与访问接口测试 =====" << std::endl;
//
//    MyVector::vector<std::string> vec;
//    vec.push_back("apple");
//    vec.push_back("banana");
//    vec.push_back("cherry");
//
//    // 3.1 迭代器遍历
//    std::string res;
//    for (MyVector::vector<std::string>::iterator it = vec.begin(); it != vec.end(); ++it) {
//        res += *it + ",";
//    }
//    TEST_ASSERT(res == "apple,banana,cherry,", "迭代器正向遍历");
//
//    // 3.2 常量迭代器
//    const MyVector::vector<std::string> cvec = vec;
//    res.clear();
//    for (auto it = cvec.begin(); it != cvec.end(); ++it) {
//        res += *it;
//    }
//    TEST_ASSERT(res == "applebananacherry", "常量迭代器遍历");
//
//    // 3.3 元素访问（[]/at/front/back）
//    TEST_ASSERT(vec[1] == "banana", "operator[]访问");
//    TEST_ASSERT(vec.at(2) == "cherry", "at()访问");
//    TEST_ASSERT(vec.front() == "apple" && vec.back() == "cherry", "front()/back()访问");
//
//    // 3.4 at()越界抛出异常
//    bool thrown = false;
//    try { vec.at(3); }
//    catch (const std::out_of_range&) { thrown = true; }
//    TEST_ASSERT(thrown, "at()越界抛出异常");
//}
//
//// 4. 测试修改操作（push_back/pop_back/insert/erase/resize）
//void testModifyOperations() {
//    std::cout << "\n===== 3. 修改操作测试 =====" << std::endl;
//
//    MyVector::vector<int> vec;
//
//    // 4.1 push_back与扩容
//    vec.push_back(1);
//    vec.push_back(2);
//    vec.push_back(3);
//    vec.push_back(4);
//    TEST_ASSERT(vec.size() == 4 && vec.capacity() == 4, "push_back至初始容量");
//    vec.push_back(5);  // 触发扩容（4→8）
//    TEST_ASSERT(vec.capacity() == 8 && vec[4] == 5, "push_back触发扩容");
//
//    // 4.2 pop_back
//    vec.pop_back();
//    TEST_ASSERT(vec.size() == 4 && vec.back() == 4, "pop_back减少元素");
//
//    // 4.3 insert（迭代器+索引）
//    vec.insert(vec.begin() + 1, 9);  // 迭代器插入
//    TEST_ASSERT(vec[1] == 9 && vec.size() == 5, "迭代器insert");
//    vec.insert(3, 10);  // 索引插入
//    TEST_ASSERT(vec[3] == 10 && vec.size() == 6, "索引insert");
//
//    // 4.4 erase（单个+范围）
//    vec.erase(vec.begin() + 2);  // 单个删除
//    TEST_ASSERT(vec[2] == 10 && vec.size() == 5, "erase单个元素");
//    vec.erase(vec.begin() + 1, vec.begin() + 3);  // 范围删除
//    TEST_ASSERT(vec.size() == 3 && vec[1] == 3, "erase范围元素");
//
//    // 4.5 resize（缩小+扩大）
//    vec.resize(2);  // 缩小
//    TEST_ASSERT(vec.size() == 2 && vec.capacity() == 8, "resize缩小（容量不变）");
//    vec.resize(5, 7);  // 扩大并填充7
//    TEST_ASSERT(vec.size() == 5 && vec[4] == 7, "resize扩大（填充值）");
//}
//
//// 5. 测试赋值、交换与比较运算符
//void testAssignSwapCompare() {
//    std::cout << "\n===== 4. 赋值、交换与比较测试 =====" << std::endl;
//
//    MyVector::vector<int> vec1(3, 2);  // [2,2,2]
//    MyVector::vector<int> vec2(3, 3);  // [3,3,3]
//    MyVector::vector<int> vec3(vec1);  // [2,2,2]
//
//    // 5.1 拷贝赋值
//    vec2 = vec1;
//    TEST_ASSERT(vec2 == vec1 && vec2.capacity() == vec1.capacity(), "拷贝赋值运算符");
//
//    // 5.2 swap（全局+成员）
//    MyVector::swap(vec1, vec3);  // 全局swap
//    TEST_ASSERT(vec1[0] == 2 && vec3[0] == 2, "全局swap（验证交换逻辑）");
//    vec1.push_back(5);
//    vec1.swap(vec3);  // 成员swap
//    TEST_ASSERT(vec3.size() == 4 && vec1.size() == 3, "成员swap交换大小");
//
//    // 5.3 比较运算符
//    MyVector::vector<int> a;
//    a.push_back(1);
//    a.push_back(3);
//    a.push_back(5);
//
//    MyVector::vector<int> b;
//    b.push_back(1);
//    b.push_back(2);
//    b.push_back(6);
//
//    MyVector::vector<int> c(a);
//
//    TEST_ASSERT(a != b, "operator!= 成立");
//    TEST_ASSERT(a > b, "operator> 成立（a[1]=3 > b[1]=2）");
//    TEST_ASSERT(a <= c, "operator<= 成立（a==c）");
//    TEST_ASSERT(b < a, "operator< 成立");
//}
//
//// 6. 测试容量操作（reserve/shrink_to_fit/clear）
//void testCapacityOperations() {
//    std::cout << "\n===== 5. 容量操作测试 =====" << std::endl;
//
//    MyVector::vector<int> vec;
//
//    // 6.1 reserve（预分配）
//    vec.reserve(10);
//    TEST_ASSERT(vec.capacity() == 10 && vec.size() == 0, "reserve预分配容量");
//    vec.reserve(5);  // 容量不缩小
//    TEST_ASSERT(vec.capacity() == 10, "reserve小于当前容量不生效");
//
//    // 6.2 shrink_to_fit（缩容）
//    vec.push_back(1);
//    vec.push_back(2);
//    vec.shrink_to_fit();
//    TEST_ASSERT(vec.capacity() == vec.size() && vec.size() == 2, "shrink_to_fit缩容至size");
//
//    // 6.3 clear（清空）
//    vec.clear();
//    TEST_ASSERT(vec.empty() && vec.capacity() == 2, "clear清空size（容量不变）");
//}
//
//// 7. 测试输入输出运算符
//void testIOOperators() {
//    std::cout << "\n===== 6. 输入输出运算符测试 =====" << std::endl;
//
//    // 6.1 operator<<（输出测试：打印预设vector）
//    MyVector::vector<int> vec;
//    vec.push_back(1);
//    vec.push_back(2);
//    vec.push_back(3);
//    vec.push_back(4);
//    std::cout << "【输出测试】预设vector内容: " << vec << std::endl;  // 预期：[1, 2, 3, 4]
//
//    // 6.2 operator>>（输入测试：手动从控制台输入）
//    MyVector::vector<int> input_vec;
//    std::cout << "\n【输入测试】请输入若干整数（用空格分隔，输入非整数字符结束）: ";
//    std::cin >> input_vec;  // 读取输入，直到遇到非整数（如回车+字母）
//
//    // 验证输入结果并打印
//    std::cout << "【输入结果】你输入的vector内容: " << input_vec << std::endl;
//    // 简单断言：确保至少输入了3个元素（可根据实际输入调整）
//    bool input_ok = (input_vec.size() >= 3) && (input_vec[0] == 10) && (input_vec[1] == 20) && (input_vec[2] == 30);
//    TEST_ASSERT(input_ok, "operator>>输入测试（需手动输入 10 20 30 验证）");
//
//    // 清除cin的错误状态（避免影响后续输入，若有）
//    std::cin.clear();
//    // 忽略缓冲区中剩余的字符（如回车、未读取的输入）
//    std::cin.ignore(std::numeric_limits<std::streamsize>::max(), '\n');
//}
//
//// 主函数：运行所有测试
////int main() 
////{
////    std::cout << "===== MyVector::vector 测试启动 =====" << std::endl;
////
////    testConstructor();
////    testIteratorAndAccess();
////    testModifyOperations();
////    testAssignSwapCompare();
////    testCapacityOperations();
////    testIOOperators();
////
////    std::cout << "\n===== 所有测试结束 =====" << std::endl;
////    return 0;
////}
//
//#include"bitvector.h"
//
//void test_vector_01()
//{
//    bitvector::vector<int> v1;
//    v1.push_back(1);
//    v1.push_back(2);
//    v1.push_back(3);
//    v1.push_back(4);
//    v1.push_back(4);
//    v1.push_back(4);
//
//    for (size_t i = 0; i < v1.size(); i++)
//    {
//        std::cout << v1[i] << " ";
//    }
//    std::cout << std::endl;
//
//    for (auto e : v1)
//    {
//        std::cout << e << " ";
//    }
//    std::cout << std::endl;
//
//    v1.pop_back();
//    v1.pop_back();
//    v1.pop_back();
//    v1.pop_back();
//    v1.pop_back();
//    v1.pop_back();
//
//    bitvector::vector<int>::iterator it1 = v1.begin();
//    while (it1 != v1.end())
//    {
//        std::cout << *it1 << " ";
//        it1++;
//    }
//    std::cout << std::endl;
//}
//
//void test_vector_02()
//{
//    bitvector::vector<int> v1;
//    v1.push_back(1);
//    v1.push_back(2);
//    v1.push_back(3);
//    v1.push_back(4);
//    for (auto e : v1)
//    {
//        std::cout << e << " ";
//    }
//    std::cout << std::endl;
//
//    v1.insert(v1.begin() + 2, 30);
//
//    for (auto e : v1)
//    {
//        std::cout << e << " ";
//    }
//    std::cout << std::endl;
//}
//
//void test_vector_03()
//{
//    // 测试构造与遍历
//    bitvector::vector<int> v1 = { 1, 2, 3, 4 };
//    for (int e : v1) std::cout << e << " ";  // 1 2 3 4
//    std::cout << "\n";
//
//    // 测试insert与erase
//    v1.insert(v1.begin() + 2, 10);
//    for (int e : v1) std::cout << e << " ";  // 1 2 10 3 4
//    std::cout << "\n";
//
//    v1.erase(v1.begin() + 1);
//    for (int e : v1) std::cout << e << " ";  // 1 10 3 4
//    std::cout << "\n";
//
//    // 测试拷贝与赋值
//    bitvector::vector<int> v2(v1);
//    bitvector::vector<int> v3;
//    v3 = v2;
//    v3.push_back(99);
//    for (int e : v3) std::cout << e << " ";  // 1 10 3 4 0 0 99
//    std::cout << "\n";
//}
//
//void test_vector_04()
//{
//    bitvector::vector<int> v1;
//    v1.push_back(1);
//    v1.push_back(2);
//    v1.push_back(3);
//    v1.push_back(4);
//
//    for (auto e : v1)
//    {
//        std::cout << e << " ";
//    }
//    std::cout << std::endl;
//
//    int x;
//    std::cin >> x;
//    auto it = std::find(v1.begin(), v1.end(), x);
//    if (it != v1.end())
//    {
//        it = v1.insert(it, 10 * x);
//        std::cout << *it << std::endl;
//    }
//    else
//    {
//        std::cout << "Not found!" << std::endl;
//    }
//    for (auto e : v1)
//    {
//        std::cout << e << " ";
//    }
//    std::cout << std::endl;
//}
//
//void test_vector_05()
//{
//    bitvector::vector<int> v1;
//    v1.push_back(1);
//    v1.push_back(2);
//    v1.push_back(2);
//    v1.push_back(3);
//    v1.push_back(4);
//    v1.push_back(5);
//    v1.push_back(2);
//
//    for (auto e : v1)
//    {
//        std::cout << e << " ";
//    }
//    std::cout << std::endl;
//
//    /*int x;
//    std::cin >> x;
//    auto it = std::find(v1.begin(), v1.end(), x);
//    if (it != v1.end())
//    {
//        v1.erase(it);
//        std::cout << *it << std::endl;
//    }
//    else
//    {
//        std::cout << "Not found!" << std::endl;
//    }
//    for (auto e : v1)
//    {
//        std::cout << e << " ";
//    }
//    std::cout << std::endl;*/
//
//    // 删除所有偶数
//    auto it = v1.begin();
//    while (it != v1.end())
//    {
//        if (*it % 2 == 0)
//        {
//            it = v1.erase(it);
//        }
//        else
//        {
//            ++it;
//        }
//    }
//    for (auto e : v1)
//    {
//        std::cout << e << " ";
//    }
//    std::cout << std::endl;
//
//
//
//}
//
////int main()
////{
////    //test_vector_01();
////    //test_vector_02();
////    //test_vector_03();
////    //test_vector_04();
////    test_vector_05();
////
////    return 0;
////}
//
///////////////////////////////////////////////////////////////////////////////////////////
//// 以下为bitvector的测试代码
///////////////////////////////////////////////////////////////////////////////////////////
//#include "vector.h"
//#include <iostream>
//#include <string>
//#include <cassert>
//
//// 辅助类：无默认构造函数（用于测试reserve是否依赖默认构造）
//class NoDefault {
//private:
//    int _value;
//public:
//    // 仅提供带参构造函数
//    NoDefault(int val) : _value(val) {}
//
//    // 提供拷贝构造和赋值运算符（vector内部需要）
//    NoDefault(const NoDefault& other) : _value(other._value) {}
//    NoDefault& operator=(const NoDefault& other) {
//        _value = other._value;
//        return *this;
//    }
//
//    int getValue() const { return _value; }
//};
//
//// 辅助类：带资源的自定义类型（用于测试内存泄漏）
//class ResourceHolder {
//private:
//    int* _data;
//public:
//    ResourceHolder(int val = 0) : _data(new int(val)) {}
//    ResourceHolder(const ResourceHolder& other) : _data(new int(*other._data)) {}
//    ResourceHolder& operator=(const ResourceHolder& other) {
//        if (this != &other) {
//            *_data = *other._data;
//        }
//        return *this;
//    }
//    ~ResourceHolder() { delete _data; } // 析构时释放资源
//
//    int getValue() const { return *_data; }
//    void setValue(int val) { *_data = val; }
//};
//
//// 测试1：基础构造与迭代器遍历
//void test_construction_and_iteration() {
//    std::cout << "=== 测试1：基础构造与迭代器 ===" << std::endl;
//
//    // 测试默认构造
//    bitvector::vector<int> v1;
//    assert(v1.empty() && v1.size() == 0 && v1.capacity() == 0);
//
//    // 测试初始化列表构造
//    bitvector::vector<int> v2 = { 1, 2, 3, 4, 5 };
//    assert(v2.size() == 5 && v2.capacity() >= 5);
//    std::cout << "初始化列表构造: ";
//    for (int e : v2) std::cout << e << " ";
//    std::cout << std::endl;
//
//    // 测试n个元素构造
//    bitvector::vector<std::string> v3(3, "test");
//    assert(v3.size() == 3);
//    std::cout << "n个元素构造: ";
//    for (const auto& s : v3) std::cout << s << " ";
//    std::cout << "\n" << std::endl;
//}
//
//// 测试2：容量操作（reserve/resize）
//void test_capacity_operations() {
//    std::cout << "=== 测试2：容量操作 ===" << std::endl;
//
//    bitvector::vector<int> v;
//
//    // 测试reserve扩容
//    v.reserve(10);
//    assert(v.capacity() >= 10 && v.size() == 0);
//
//    // 测试reserve缩小（不改变容量）
//    v.reserve(5);
//    assert(v.capacity() >= 10);
//
//    // 测试自动扩容
//    for (int i = 0; i < 15; ++i) {
//        v.push_back(i);
//    }
//    assert(v.size() == 15 && v.capacity() >= 15);
//    std::cout << "自动扩容后: size=" << v.size() << ", capacity=" << v.capacity() << std::endl;
//
//    // 测试resize扩大
//    v.resize(20, 99);
//    assert(v.size() == 20);
//    std::cout << "resize扩大后最后5个元素: ";
//    for (size_t i = 15; i < 20; ++i) std::cout << v[i] << " ";
//    std::cout << std::endl;
//
//    // 测试resize缩小
//    v.resize(5);
//    assert(v.size() == 5);
//    std::cout << "resize缩小后元素: ";
//    for (int e : v) std::cout << e << " ";
//    std::cout << "\n" << std::endl;
//}
//
//// 测试3：元素插入与删除
//void test_insert_and_erase() {
//    std::cout << "=== 测试3：插入与删除 ===" << std::endl;
//
//    bitvector::vector<char> v = { 'a', 'b', 'c', 'd' };
//
//    // 测试push_back
//    v.push_back('e');
//    assert(v.back() == 'e' && v.size() == 5); // 此时size=5
//
//    // 测试insert中间插入
//    auto it = v.insert(v.begin() + 2, 'x');
//    // 插入后size应为5+1=6，it指向插入的'x'
//    assert(*it == 'x' && v.size() == 6);
//    std::cout << "insert后元素: ";
//    for (char c : v) std::cout << c << " "; // 预期：a b x c d e
//    std::cout << std::endl;
//
//    // 测试erase中间元素
//    it = v.erase(v.begin() + 1); // 删除'b'
//    std::cout << "erase返回值指向: " << *it << std::endl; // 应指向删除后的位置，即'x'
//	// 删除后size应为6-1=5，it应指向'x'
//    assert(*it == 'x');
//	std::cout << "size after erase: " << v.size() << std::endl;
//    assert(v.size() == 5); // erase后size=6-1=5
//    std::cout << "erase后元素: ";
//    for (char c : v) std::cout << c << " "; // 预期：a x c d e
//    std::cout << std::endl;
//
//    // 测试pop_back
//    v.pop_back();
//    assert(v.back() == 'd' && v.size() == 4);
//
//    // 测试clear
//    v.clear();
//    assert(v.empty() && v.capacity() >= 5);
//    std::cout << "clear后: size=" << v.size() << ", capacity=" << v.capacity() << "\n" << std::endl;
//}
//
//// 测试4：拷贝构造与赋值
//void test_copy_and_assign() {
//    std::cout << "=== 测试4：拷贝与赋值 ===" << std::endl;
//
//    bitvector::vector<int> v1 = { 10, 20, 30 };
//
//    // 测试拷贝构造
//    bitvector::vector<int> v2(v1);
//    v2[0] = 100;
//    assert(v1[0] == 10 && v2[0] == 100); // 验证深拷贝
//
//    // 测试赋值运算符（非const对象）
//    bitvector::vector<int> v3;
//    v3 = v1;
//    v3[1] = 200;
//    assert(v1[1] == 20 && v3[1] == 200);
//
//    // 测试赋值运算符（临时对象）
//    v3 = bitvector::vector<int>{ 40, 50, 60 };
//    assert(v3.size() == 3 && v3[0] == 40);
//
//    // 测试swap
//    bitvector::swap(v1, v3);
//    assert(v1[0] == 40 && v3[0] == 10);
//    std::cout << "swap后v1: ";
//    for (int e : v1) std::cout << e << " ";
//    std::cout << "\n" << std::endl;
//}
//
//// 测试5：自定义类型支持（无默认构造函数）
//void test_no_default_constructor() {
//    std::cout << "=== 测试5：无默认构造类型支持 ===" << std::endl;
//
//    // 测试无默认构造类型的构造
//    bitvector::vector<NoDefault> v;
//    v.push_back(NoDefault(1));
//    v.push_back(NoDefault(2));
//    v.push_back(NoDefault(3));
//
//    // 测试访问
//    assert(v[0].getValue() == 1 && v[2].getValue() == 3);
//
//    // 测试insert和erase
//    auto it = v.insert(v.begin() + 1, NoDefault(100));
//    assert(it->getValue() == 100 && v.size() == 4);
//
//    it = v.erase(v.begin() + 2);
//   
//    std::cout << it->getValue() << std::endl;
//    std::cout << v.size() << std::endl;
//    assert(it->getValue() == 2 && v.size() == 3);
//
//    std::cout << "无默认构造类型元素: ";
//    for (const auto& nd : v) std::cout << nd.getValue() << " ";
//    std::cout << "\n" << std::endl;
//}
//
//// 测试6：资源管理（验证无内存泄漏）
//void test_resource_management() {
//    std::cout << "=== 测试6：资源管理（无内存泄漏） ===" << std::endl;
//
//    // 测试带资源的自定义类型
//    bitvector::vector<ResourceHolder> v;
//
//    // 添加元素
//    v.push_back(ResourceHolder(10));
//    v.push_back(ResourceHolder(20));
//
//    // 修改元素
//    v[0].setValue(100);
//    assert(v[0].getValue() == 100);
//
//    // 测试erase是否释放资源
//    v.erase(v.begin());
//    assert(v.size() == 1 && v[0].getValue() == 20);
//
//    // 测试resize缩小是否释放资源
//    v.resize(0);
//    assert(v.empty());
//
//    // 测试拷贝后修改是否影响原对象
//    bitvector::vector<ResourceHolder> v2;
//    v2.push_back(ResourceHolder(30));
//    v = v2;
//    v2[0].setValue(300);
//    assert(v[0].getValue() == 30); // 深拷贝验证
//
//    std::cout << "资源管理测试通过（无内存泄漏）" << "\n" << std::endl;
//}
//
//// 测试7：边界情况与异常
//void test_edge_cases() {
//    std::cout << "=== 测试7：边界情况 ===" << std::endl;
//
//    // 测试空容器操作
//    bitvector::vector<int> v;
//    try {
//        v.front(); // 应触发断言
//    }
//    catch (...) {
//        std::cout << "空容器调用front()触发断言（正常）" << std::endl;
//    }
//
//    // 测试单元素容器
//    v.push_back(5);
//    assert(v.front() == 5 && v.back() == 5);
//    v.pop_back();
//    assert(v.empty());
//
//    // 测试迭代器失效场景（通过返回值更新）
//    v = { 1, 2, 3, 4 };
//    auto it = v.begin() + 2;
//    it = v.insert(it, 9); // 插入后更新迭代器
//    assert(*it == 9 && *(it + 1) == 3);
//
//    it = v.erase(it); // 删除后更新迭代器
//    assert(*it == 3);
//
//    std::cout << "边界情况测试通过" << std::endl;
//}
//
////int main() {
////    // 运行所有测试
////    test_construction_and_iteration();
////    test_capacity_operations();
////    test_insert_and_erase();
////    test_copy_and_assign();
////    test_no_default_constructor();
////    test_resource_management();
////    test_edge_cases();
////
////    std::cout << "\n所有测试通过！" << std::endl;
////    system("pause");
////    return 0;
////}
//////////////////////////////////////////
//// 以下为bitvector的测试代码
//////////////////////////////////////////
//#include <iostream>
//#include <string>
//#include <cassert>
//#include "vector.h"  // 包含您实现的vector头文件
//
//using namespace bitvector;
//
//// 测试基本功能
//void test_basic_operations() {
//    vector<int> v;
//    assert(v.empty() == true);
//    assert(v.size() == 0);
//    assert(v.capacity() == 0);
//
//    v.push_back(1);
//    v.push_back(2);
//    v.push_back(3);
//
//    assert(v.size() == 3);
//    assert(v.capacity() >= 3);
//    assert(v[0] == 1);
//    assert(v[1] == 2);
//    assert(v[2] == 3);
//    assert(v.front() == 1);
//    assert(v.back() == 3);
//
//    v.pop_back();
//    assert(v.size() == 2);
//    assert(v.back() == 2);
//
//    v.clear();
//    assert(v.empty() == true);
//    assert(v.size() == 0);
//    assert(v.capacity() >= 2);  // clear不改变容量
//
//    std::cout << "Basic operations test passed!\n";
//}
//
//// 测试迭代器功能
//void test_iterators() {
//    vector<std::string> v;
//    v.push_back("apple");
//    v.push_back("banana");
//    v.push_back("cherry");
//
//    // 测试普通迭代器
//    int count = 0;
//    for (auto it = v.begin(); it != v.end(); ++it) {
//        count++;
//    }
//    assert(count == 3);
//
//    // 测试const迭代器
//    const vector<std::string>& cv = v;
//    std::string result;
//    for (auto it = cv.cbegin(); it != cv.cend(); ++it) {
//        result += *it;
//    }
//    assert(result == "applebananacherry");
//
//    std::cout << "Iterators test passed!\n";
//}
//
//// 测试容量相关函数
//void test_capacity() {
//    vector<double> v;
//    assert(v.capacity() == 0);
//
//    v.reserve(10);
//    assert(v.capacity() >= 10);
//    assert(v.size() == 0);
//
//    v.push_back(3.14);
//    v.push_back(2.718);
//    assert(v.size() == 2);
//    assert(v.capacity() >= 10);
//
//    v.resize(5);
//    assert(v.size() == 5);
//    assert(v[4] == 0.0);  // 内置类型默认初始化
//
//    v.resize(3);
//    assert(v.size() == 3);
//    assert(v.capacity() >= 10);
//
//    std::cout << "Capacity test passed!\n";
//}
//
//// 测试插入和删除
//void test_insert_erase() {
//    vector<int> v;
//    for (int i = 0; i < 5; ++i) {
//        v.push_back(i);
//    }
//
//    // 测试insert
//    auto it = v.insert(v.begin() + 2, 99);
//    assert(*it == 99);
//    assert(v.size() == 6);
//    assert(v[2] == 99);
//    assert(v[3] == 2);  // 原元素后移
//
//    // 测试erase
//    it = v.erase(v.begin() + 2);
//    assert(*it == 2);  // 指向被删除元素的下一个
//    assert(v.size() == 5);
//    assert(v[2] == 2);  // 验证元素前移
//
//    std::cout << "Insert/erase test passed!\n";
//}
//
//// 测试拷贝构造和赋值
//void test_copy_assignment() {
//    vector<int> v1;
//    for (int i = 0; i < 5; ++i) {
//        v1.push_back(i);
//    }
//
//    // 测试拷贝构造
//    vector<int> v2(v1);
//    assert(v2.size() == v1.size());
//    assert(v2.capacity() == v1.capacity());
//    for (size_t i = 0; i < v1.size(); ++i) {
//        assert(v1[i] == v2[i]);
//    }
//
//    // 测试赋值运算符
//    vector<int> v3;
//    v3 = v1;
//    assert(v3.size() == v1.size());
//    for (size_t i = 0; i < v1.size(); ++i) {
//        assert(v1[i] == v3[i]);
//    }
//
//    // 测试自我赋值
//    v1 = v1;
//    assert(v1.size() == 5);
//
//    std::cout << "Copy/assignment test passed!\n";
//}
//
//// 测试初始化列表
//void test_initializer_list() {
//    vector<int> v = { 1, 2, 3, 4, 5 };
//    assert(v.size() == 5);
//    for (int i = 0; i < 5; ++i) {
//        assert(v[i] == i + 1);
//    }
//
//    std::cout << "Initializer list test passed!\n";
//}
//
//// 测试自定义类型
//class TestClass {
//private:
//    int value;
//public:
//    TestClass(int v = 0) : value(v) {}
//    TestClass(const TestClass& other) : value(other.value) {}
//    ~TestClass() {}
//
//    TestClass& operator=(const TestClass& other) {
//        if (this != &other) {
//            value = other.value;
//        }
//        return *this;
//    }
//
//    bool operator==(const TestClass& other) const {
//        return value == other.value;
//    }
//};
//
//void test_custom_type() {
//    vector<TestClass> v;
//    v.push_back(TestClass(10));
//    v.push_back(TestClass(20));
//    v.push_back(TestClass(30));
//
//    assert(v.size() == 3);
//    assert(v[1] == TestClass(20));
//
//    vector<TestClass> v2(v);
//    assert(v2.size() == 3);
//    assert(v2[2] == TestClass(30));
//
//    std::cout << "Custom type test passed!\n";
//}
//
////int main() {
////    test_basic_operations();
////    test_iterators();
////    test_capacity();
////    test_insert_erase();
////    test_copy_assignment();
////    test_initializer_list();
////    test_custom_type();
////
////    std::cout << "All tests passed successfully!\n";
////    return 0;
////}
